package com.ruoyi.base.service.impl;

import java.util.List;

import com.ruoyi.base.domain.BaseDevice;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.base.mapper.BaseTypeMapper;
import com.ruoyi.base.domain.BaseType;
import com.ruoyi.base.service.IBaseTypeService;

import javax.annotation.PostConstruct;

/**
 * 设备类型Service业务层处理
 * 
 * @author yepanpan
 * @date 2025-02-28
 */
@Service
public class BaseTypeServiceImpl implements IBaseTypeService 
{
    public static final String CACHE_MAP = "base_type";
    private static final Logger log = LoggerFactory.getLogger(BaseTypeServiceImpl.class);

    @Autowired
    private BaseTypeMapper baseTypeMapper;
    @Autowired
    private RedisCache redisCache;


    @PostConstruct
    public int reCache(){
        redisCache.deleteObject(CACHE_MAP);
        return 0;
    }

    /**
     * 查询设备类型
     *
     * @param code 设备类型代码
     * @return 设备类型
     */
    public BaseType selectBaseTypeByCode(String code){
        Long id = redisCache.getCacheMapValue(CACHE_MAP, code);
        if(id != null){
            return selectBaseTypeById(id);
        }

        BaseType baseType = baseTypeMapper.selectBaseTypeByCode(code);
        if(baseType == null){
            return baseType;
        }

        redisCache.setCacheMapValue(CACHE_MAP, code, baseType.getId());
        redisCache.setCacheMapValue(CACHE_MAP, "id_"+baseType.getId(), baseType);
        return baseType;
    }

    /**
     * 查询设备类型
     * 
     * @param id 设备类型主键
     * @return 设备类型
     */
    @Override
    public BaseType selectBaseTypeById(Long id)
    {
        String key = "id_"+id;
        BaseType baseType = redisCache.getCacheMapValue(CACHE_MAP, key);
        if(baseType != null){
            return baseType;
        }
        baseType = baseTypeMapper.selectBaseTypeById(id);

        if(baseType == null){
            return baseType;
        }

        redisCache.setCacheMapValue(CACHE_MAP, baseType.getCode(), baseType.getId());
        redisCache.setCacheMapValue(CACHE_MAP, key, baseType);
        return baseType;
    }

    /**
     * 查询设备类型列表
     * 
     * @param baseType 设备类型
     * @return 设备类型
     */
    @Override
    public List<BaseType> selectBaseTypeList(BaseType baseType)
    {
        return baseTypeMapper.selectBaseTypeList(baseType);
    }

    /**
     * 新增设备类型
     * 
     * @param baseType 设备类型
     * @return 结果
     */
    @Override
    public int insertBaseType(BaseType baseType)
    {
        if(!baseType.getParentId().equals(0L)){
            BaseType info = baseTypeMapper.selectBaseTypeById(baseType.getParentId());
            baseType.setAncestors(info.getAncestors()+","+baseType.getParentId());
        }else{
            baseType.setAncestors(baseType.getParentId()+"");
        }

        baseType.setCreateTime(DateUtils.getNowDate());
        return baseTypeMapper.insertBaseType(baseType);
    }

    /**
     * 修改设备类型
     * 
     * @param baseType 设备类型
     * @return 结果
     */
    @Override
    public int updateBaseType(BaseType baseType)
    {
        //再判断是否更新树形结构
        BaseType old = baseTypeMapper.selectBaseTypeById(baseType.getId());
        if(!old.getParentId().equals(baseType.getParentId())){
            String oldAncestors = old.getAncestors();
            if(!baseType.getParentId().equals(0L)){
                BaseType info = baseTypeMapper.selectBaseTypeById(baseType.getParentId());
                baseType.setAncestors(info.getAncestors()+","+baseType.getParentId());
            }else{
                baseType.setAncestors(baseType.getParentId()+"");
            }
            String newAncestors = baseType.getAncestors();
            updateBaseTypeChildren(baseType.getId(), newAncestors, oldAncestors);
        }

        baseType.setUpdateTime(DateUtils.getNowDate());
        return baseTypeMapper.updateBaseType(baseType) + reCache();
    }

    /**
     * 修改子元素关系
     *
     * @param typeId 被修改的分类ID
     * @param newAncestors 新的父ID集合
     * @param oldAncestors 旧的父ID集合
     */
    public void updateBaseTypeChildren(Long typeId, String newAncestors, String oldAncestors)
    {
        List<BaseType> children = baseTypeMapper.selectChildrenTypeById(typeId);
        for (BaseType child : children)
        {
            child.setAncestors(child.getAncestors().replaceFirst(oldAncestors, newAncestors));
        }
        if (children.size() > 0)
        {
            baseTypeMapper.updateBaseTypeChildren(children);
        }
    }

    /**
     * 批量删除设备类型
     * 
     * @param ids 需要删除的设备类型主键
     * @return 结果
     */
    @Override
    public int deleteBaseTypeByIds(Long[] ids)
    {
        return baseTypeMapper.deleteBaseTypeByIds(ids) + reCache();
    }

    /**
     * 删除设备类型信息
     * 
     * @param id 设备类型主键
     * @return 结果
     */
    @Override
    public int deleteBaseTypeById(Long id)
    {
        return baseTypeMapper.deleteBaseTypeById(id) + reCache();
    }


}
